home *** CD-ROM | disk | FTP | other *** search
/ Champak 138 / Volume 138 Aug 19 2011 - Damaged.iso / Games / super_racer.swf / scripts / DefineSprite_268_trackCheckpoint / frame_149 / DoAction.as
Text File  |  2011-08-19  |  32KB  |  494 lines

  1. function ┬º\x01\x02┬º()
  2. {
  3.    return 1623 % 511 * 5;
  4. }
  5. var ┬º\x01┬º = 541 + "\x01\x02"();
  6. loop0:
  7. while(true)
  8. {
  9.    if(eval("\x01") != 991)
  10.    {
  11.       if(eval("\x01") != 657)
  12.       {
  13.          if(eval("\x01") != 86)
  14.          {
  15.             if(eval("\x01") != 337)
  16.             {
  17.                if(eval("\x01") != 663)
  18.                {
  19.                   if(eval("\x01") != 314)
  20.                   {
  21.                      if(eval("\x01") != 405)
  22.                      {
  23.                         if(eval("\x01") != 892)
  24.                         {
  25.                            if(eval("\x01") == 977)
  26.                            {
  27.                               set("\x01",eval("\x01") - 640);
  28.                               break;
  29.                            }
  30.                            if(eval("\x01") != 670)
  31.                            {
  32.                               if(eval("\x01") != 562)
  33.                               {
  34.                                  if(eval("\x01") != 201)
  35.                                  {
  36.                                     if(eval("\x01") != 220)
  37.                                     {
  38.                                        if(eval("\x01") == 808)
  39.                                        {
  40.                                           set("\x01",eval("\x01") - 151);
  41.                                           break;
  42.                                        }
  43.                                        if(eval("\x01") == 599)
  44.                                        {
  45.                                           set("\x01",eval("\x01") + 209);
  46.                                           if(function ┬º\x01\x02┬º()
  47.                                           {
  48.                                              return 1623 % 511 * 5;
  49.                                           })
  50.                                           {
  51.                                              set("\x01",eval("\x01") - 151);
  52.                                           }
  53.                                           continue;
  54.                                        }
  55.                                        if(eval("\x01") == 109)
  56.                                        {
  57.                                           set("\x01",eval("\x01") + 446);
  58.                                           continue;
  59.                                           continue;
  60.                                        }
  61.                                        if(eval("\x01") == 929)
  62.                                        {
  63.                                           set("\x01",eval("\x01") - 615);
  64.                                           continue;
  65.                                           continue;
  66.                                        }
  67.                                        if(eval("\x01") == 555)
  68.                                        {
  69.                                           set("\x01",eval("\x01") + 115);
  70.                                           ┬º┬ºpush(true);
  71.                                           continue;
  72.                                        }
  73.                                        if(eval("\x01") == 330)
  74.                                        {
  75.                                           set("\x01",eval("\x01") + 390);
  76.                                           ┬º┬ºpush(true);
  77.                                           continue;
  78.                                        }
  79.                                        if(eval("\x01") == 720)
  80.                                        {
  81.                                           set("\x01",eval("\x01") + 257);
  82.                                           if(function ┬º\x01\x02┬º()
  83.                                           {
  84.                                              return 1623 % 511 * 5;
  85.                                           })
  86.                                           {
  87.                                              set("\x01",eval("\x01") - 640);
  88.                                           }
  89.                                           continue;
  90.                                        }
  91.                                     }
  92.                                     set("\x01",eval("\x01") + 551);
  93.                                     continue;
  94.                                     if(eval("\x01") == 645)
  95.                                     {
  96.                                        set("\x01",eval("\x01") + 111);
  97.                                        break;
  98.                                     }
  99.                                     if(eval("\x01") == 140)
  100.                                     {
  101.                                        set("\x01",eval("\x01") + 504);
  102.                                        if(function ┬º\x01\x02┬º()
  103.                                        {
  104.                                           return 1623 % 511 * 5;
  105.                                        })
  106.                                        {
  107.                                           set("\x01",eval("\x01") - 82);
  108.                                        }
  109.                                        continue;
  110.                                     }
  111.                                  }
  112.                                  set("\x01",eval("\x01") + 462);
  113.                                  ┬º┬ºpush(eval(function ┬º\x01\x02┬º()
  114.                                  {
  115.                                     return 1623 % 511 * 5;
  116.                                  }));
  117.                                  continue;
  118.                                  if(eval("\x01") != 756)
  119.                                  {
  120.                                     if(eval("\x01") == 644)
  121.                                     {
  122.                                        set("\x01",eval("\x01") - 82);
  123.                                        loop1:
  124.                                        while(true)
  125.                                        {
  126.                                           set(┬º┬ºpop(),eval(function ┬º\x01\x02┬º()
  127.                                           {
  128.                                              return 1623 % 511 * 5;
  129.                                           }) - 207);
  130.                                           while(true)
  131.                                           {
  132.                                              if(eval("\x01") != 664)
  133.                                              {
  134.                                                 if(eval("\x01") != 457)
  135.                                                 {
  136.                                                    if(eval("\x01") != 35)
  137.                                                    {
  138.                                                       if(eval("\x01") != 266)
  139.                                                       {
  140.                                                          if(eval("\x01") != 330)
  141.                                                          {
  142.                                                             if(eval("\x01") == 834)
  143.                                                             {
  144.                                                                break loop1;
  145.                                                             }
  146.                                                             if(eval("\x01") == 161)
  147.                                                             {
  148.                                                                set("\x01",eval("\x01") + 169);
  149.                                                                ┬º┬ºpush("\x0f");
  150.                                                                ┬º┬ºpush(1);
  151.                                                                continue;
  152.                                                             }
  153.                                                             if(eval("\x01") == 302)
  154.                                                             {
  155.                                                                set("\x01",eval("\x01") + 532);
  156.                                                                if(┬º┬ºpop())
  157.                                                                {
  158.                                                                   set("\x01",eval("\x01") - 306);
  159.                                                                }
  160.                                                                continue;
  161.                                                             }
  162.                                                             if(eval("\x01") == 736)
  163.                                                             {
  164.                                                                set("\x01",eval("\x01") - 279);
  165.                                                                ┬º┬ºpush(!┬º┬ºpop());
  166.                                                                continue;
  167.                                                             }
  168.                                                             if(eval("\x01") == 184)
  169.                                                             {
  170.                                                                set("\x01",eval("\x01") + 82);
  171.                                                                ┬º┬ºpush(true);
  172.                                                                continue;
  173.                                                             }
  174.                                                             if(eval("\x01") == 26)
  175.                                                             {
  176.                                                                set("\x01",eval("\x01") + 158);
  177.                                                                continue;
  178.                                                                continue loop1;
  179.                                                             }
  180.                                                             if(eval("\x01") == 370)
  181.                                                             {
  182.                                                                set("\x01",eval("\x01") - 209);
  183.                                                                continue;
  184.                                                             }
  185.                                                          }
  186.                                                          set("\x01",eval("\x01") - 295);
  187.                                                          var ┬º┬ºpop() = ┬º┬ºpop();
  188.                                                          continue;
  189.                                                          if(eval("\x01") != 48)
  190.                                                          {
  191.                                                             if(eval("\x01") == 88)
  192.                                                             {
  193.                                                                set("\x01",eval("\x01") + 216);
  194.                                                                addr186:
  195.                                                                if(!┬º┬ºpop())
  196.                                                                {
  197.                                                                   set("\x01",eval("\x01") - 517);
  198.                                                                   addr14:
  199.                                                                   if(eval("\x01") == 505)
  200.                                                                   {
  201.                                                                      set("\x01",eval("\x01") - 298);
  202.                                                                      ┬º┬ºgoto(addr14);
  203.                                                                      ┬º┬ºpush(true);
  204.                                                                   }
  205.                                                                   if(eval("\x01") != 231)
  206.                                                                   {
  207.                                                                      if(eval("\x01") == 295)
  208.                                                                      {
  209.                                                                         set("\x01",eval("\x01") + 684);
  210.                                                                         ┬º┬ºgoto(addr14);
  211.                                                                         ┬º┬ºpush(true);
  212.                                                                      }
  213.                                                                      if(eval("\x01") == 451)
  214.                                                                      {
  215.                                                                         set("\x01",eval("\x01") + 317);
  216.                                                                         ┬º┬ºgoto(addr14);
  217.                                                                         ┬º┬ºpush(eval(┬º┬ºpop()));
  218.                                                                      }
  219.                                                                      if(eval("\x01") == 207)
  220.                                                                      {
  221.                                                                         set("\x01",eval("\x01") + 24);
  222.                                                                         if(!┬º┬ºpop())
  223.                                                                         {
  224.                                                                            addr92:
  225.                                                                            ┬º┬ºgoto(addr14);
  226.                                                                         }
  227.                                                                         set("\x01",eval("\x01") + 503);
  228.                                                                         ┬º┬ºgoto(addr92);
  229.                                                                      }
  230.                                                                      if(eval("\x01") != 219)
  231.                                                                      {
  232.                                                                         if(eval("\x01") == 979)
  233.                                                                         {
  234.                                                                            set("\x01",eval("\x01") - 760);
  235.                                                                            if(!┬º┬ºpop())
  236.                                                                            {
  237.                                                                               addr126:
  238.                                                                               ┬º┬ºgoto(addr14);
  239.                                                                            }
  240.                                                                            set("\x01",eval("\x01") + 439);
  241.                                                                            ┬º┬ºgoto(addr126);
  242.                                                                         }
  243.                                                                         if(eval("\x01") == 600)
  244.                                                                         {
  245.                                                                            set("\x01",eval("\x01") - 149);
  246.                                                                            ┬º┬ºgoto(addr14);
  247.                                                                            ┬º┬ºpush("\x0f");
  248.                                                                         }
  249.                                                                         if(eval("\x01") == 488)
  250.                                                                         {
  251.                                                                            set("\x01",eval("\x01") - 193);
  252.                                                                            ┬º┬ºgoto(addr14);
  253.                                                                         }
  254.                                                                         if(eval("\x01") == 734)
  255.                                                                         {
  256.                                                                            set("\x01",eval("\x01") - 439);
  257.                                                                            ┬º┬ºgoto(addr14);
  258.                                                                         }
  259.                                                                         if(eval("\x01") == 481)
  260.                                                                         {
  261.                                                                            set("\x01",eval("\x01") + 273);
  262.                                                                            ┬º┬ºgoto(addr14);
  263.                                                                         }
  264.                                                                         ┬º┬ºgoto(addr186);
  265.                                                                         ┬º┬ºpush(eval("\x01") != 658);
  266.                                                                      }
  267.                                                                      set("\x01",eval("\x01") + 439);
  268.                                                                      break loop0;
  269.                                                                   }
  270.                                                                   set("\x01",eval("\x01") + 503);
  271.                                                                   break loop0;
  272.                                                                }
  273.                                                                if(eval("\x01") == 575)
  274.                                                                {
  275.                                                                   set("\x01",eval("\x01") + 37);
  276.                                                                   if(!┬º┬ºpop())
  277.                                                                   {
  278.                                                                      addr214:
  279.                                                                      ┬º┬ºgoto(addr14);
  280.                                                                   }
  281.                                                                   set("\x01",eval("\x01") + 0);
  282.                                                                   ┬º┬ºgoto(addr214);
  283.                                                                }
  284.                                                                if(eval("\x01") != 237)
  285.                                                                {
  286.                                                                   if(eval("\x01") == 141)
  287.                                                                   {
  288.                                                                      set("\x01",eval("\x01") + 670);
  289.                                                                      ┬º┬ºgoto(addr14);
  290.                                                                      ┬º┬ºpush(true);
  291.                                                                   }
  292.                                                                   if(eval("\x01") == 754)
  293.                                                                   {
  294.                                                                      set("\x01",eval("\x01") - 431);
  295.                                                                      ┬º┬ºgoto(addr14);
  296.                                                                      ┬º┬ºpush("\x0f");
  297.                                                                      ┬º┬ºpush(1);
  298.                                                                   }
  299.                                                                   if(eval("\x01") == 910)
  300.                                                                   {
  301.                                                                      set("\x01",eval("\x01") - 769);
  302.                                                                      ┬º┬ºgoto(addr14);
  303.                                                                   }
  304.                                                                   if(eval("\x01") == 811)
  305.                                                                   {
  306.                                                                      set("\x01",eval("\x01") - 574);
  307.                                                                      if(!┬º┬ºpop())
  308.                                                                      {
  309.                                                                         addr290:
  310.                                                                         ┬º┬ºgoto(addr14);
  311.                                                                      }
  312.                                                                      set("\x01",eval("\x01") + 244);
  313.                                                                      ┬º┬ºgoto(addr290);
  314.                                                                   }
  315.                                                                   if(eval("\x01") == 241)
  316.                                                                   {
  317.                                                                      set("\x01",eval("\x01") + 513);
  318.                                                                      ┬º┬ºgoto(addr14);
  319.                                                                   }
  320.                                                                   if(eval("\x01") == 323)
  321.                                                                   {
  322.                                                                      set("\x01",eval("\x01") + 277);
  323.                                                                      var ┬º┬ºpop() = ┬º┬ºpop();
  324.                                                                      ┬º┬ºgoto(addr14);
  325.                                                                   }
  326.                                                                   if(eval("\x01") == 768)
  327.                                                                   {
  328.                                                                      set("\x01",eval("\x01") - 193);
  329.                                                                      ┬º┬ºgoto(addr14);
  330.                                                                      ┬º┬ºpush(!┬º┬ºpop());
  331.                                                                   }
  332.                                                                   if(eval("\x01") == 612)
  333.                                                                   {
  334.                                                                      set("\x01",eval("\x01") - 101);
  335.                                                                      hornsplaying = false;
  336.                                                                      break loop0;
  337.                                                                   }
  338.                                                                   if(eval("\x01") == 511)
  339.                                                                   {
  340.                                                                      set("\x01",eval("\x01") - 511);
  341.                                                                      break loop0;
  342.                                                                   }
  343.                                                                   break loop0;
  344.                                                                }
  345.                                                                set("\x01",eval("\x01") + 244);
  346.                                                                break loop0;
  347.                                                             }
  348.                                                             if(eval("\x01") == 528)
  349.                                                             {
  350.                                                                set("\x01",eval("\x01") - 344);
  351.                                                                continue;
  352.                                                             }
  353.                                                             if(eval("\x01") == 304)
  354.                                                             {
  355.                                                                set("\x01",eval("\x01") - 143);
  356.                                                                continue;
  357.                                                             }
  358.                                                             if(eval("\x01") != 567)
  359.                                                             {
  360.                                                                if(eval("\x01") == 360)
  361.                                                                {
  362.                                                                   set("\x01",eval("\x01") + 89);
  363.                                                                   if(eval("∩┐╜/M∩┐╜∩┐╜")["c+┬╣"] != ┬º┬ºconstant(2))
  364.                                                                   {
  365.                                                                      eval("∩┐╜/M∩┐╜∩┐╜")[┬º┬ºconstant(3)]();
  366.                                                                      eval("∩┐╜/M∩┐╜∩┐╜")[┬º┬ºconstant(4)](┬º┬ºconstant(2));
  367.                                                                      eval("∩┐╜/M∩┐╜∩┐╜")["c+┬╣"] = ┬º┬ºconstant(2);
  368.                                                                      eval("∩┐╜/M∩┐╜∩┐╜")[┬º┬ºconstant(5)] = 1;
  369.                                                                   }
  370.                                                                   break loop0;
  371.                                                                }
  372.                                                                if(eval("\x01") == 449)
  373.                                                                {
  374.                                                                   set("\x01",eval("\x01") - 449);
  375.                                                                   break loop0;
  376.                                                                }
  377.                                                             }
  378.                                                          }
  379.                                                       }
  380.                                                       set("\x01",eval("\x01") - 178);
  381.                                                       if(┬º┬ºpop())
  382.                                                       {
  383.                                                          set("\x01",eval("\x01") + 216);
  384.                                                       }
  385.                                                       continue;
  386.                                                       set("\x01",eval("\x01") + 688);
  387.                                                    }
  388.                                                    set("\x01",eval("\x01") + 13);
  389.                                                    ┬º┬ºpush("\x0f");
  390.                                                    continue;
  391.                                                 }
  392.                                                 set("\x01",eval("\x01") + 110);
  393.                                                 if(┬º┬ºpop())
  394.                                                 {
  395.                                                    set("\x01",eval("\x01") - 207);
  396.                                                 }
  397.                                                 continue;
  398.                                              }
  399.                                              set("\x01",eval("\x01") - 362);
  400.                                              ┬º┬ºpush(true);
  401.                                              continue;
  402.                                              ┬º┬ºpush(eval(┬º┬ºpop()));
  403.                                           }
  404.                                        }
  405.                                        set("\x01",eval("\x01") - 306);
  406.                                        break;
  407.                                     }
  408.                                     if(eval("\x01") == 227)
  409.                                     {
  410.                                        set("\x01",eval("\x01") + 382);
  411.                                        var ┬º┬ºpop() = function ┬º\x01\x02┬º()
  412.                                        {
  413.                                           return 1623 % 511 * 5;
  414.                                        };
  415.                                        continue;
  416.                                     }
  417.                                     if(eval("\x01") != 609)
  418.                                     {
  419.                                        if(eval("\x01") != 228)
  420.                                        {
  421.                                           if(eval("\x01") == 771)
  422.                                           {
  423.                                              set("\x01",eval("\x01") - 321);
  424.                                              _root.prevSnd.goracer = 5;
  425.                                              _root.chkSnd.goracer = 3;
  426.                                              _root.chkSnd.sfx.prevSndType(4);
  427.                                              _root[┬º┬ºconstant(6)]();
  428.                                              break;
  429.                                           }
  430.                                           if(eval("\x01") == 450)
  431.                                           {
  432.                                              set("\x01",eval("\x01") - 450);
  433.                                              break;
  434.                                           }
  435.                                        }
  436.                                        set("\x01",eval("\x01") - 8);
  437.                                        if(function ┬º\x01\x02┬º()
  438.                                        {
  439.                                           return 1623 % 511 * 5;
  440.                                        })
  441.                                        {
  442.                                           set("\x01",eval("\x01") + 551);
  443.                                        }
  444.                                     }
  445.                                     set("\x01",eval("\x01") - 408);
  446.                                     ┬º┬ºpush("\x0f");
  447.                                  }
  448.                               }
  449.                               set("\x01",eval("\x01") - 232);
  450.                               continue;
  451.                               set("\x01",eval("\x01") - 442);
  452.                            }
  453.                            set("\x01",eval("\x01") - 25);
  454.                            if(function ┬º\x01\x02┬º()
  455.                            {
  456.                               return 1623 % 511 * 5;
  457.                            })
  458.                            {
  459.                               set("\x01",eval("\x01") + 111);
  460.                            }
  461.                         }
  462.                         set("\x01",eval("\x01") - 665);
  463.                         ┬º┬ºpush("\x0f");
  464.                         ┬º┬ºpush(1);
  465.                         continue;
  466.                      }
  467.                      set("\x01",eval("\x01") + 487);
  468.                      continue;
  469.                      continue;
  470.                   }
  471.                   set("\x01",eval("\x01") - 174);
  472.                   ┬º┬ºpush(true);
  473.                   continue;
  474.                }
  475.                set("\x01",eval("\x01") - 435);
  476.                ┬º┬ºpush(!function ┬º\x01\x02┬º()
  477.                {
  478.                   return 1623 % 511 * 5;
  479.                });
  480.                continue;
  481.             }
  482.             set("\x01",eval("\x01") + 555);
  483.             continue;
  484.          }
  485.          set("\x01",eval("\x01") + 244);
  486.          continue;
  487.       }
  488.       set("\x01",eval("\x01") - 102);
  489.       continue;
  490.    }
  491.    set("\x01",eval("\x01") - 392);
  492.    ┬º┬ºpush(true);
  493. }
  494.